home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / site-packages / Numeric / Precision.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2006-03-29  |  4KB  |  199 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. ''' A simple hack to start thinking about a better way to handle
  5. specification of typecodes.
  6.  
  7. TODO:
  8.     The code_table should proably be cached somehow
  9.     Float/Complex needs to have precision and range specifiers
  10. '''
  11. from multiarray import zeros
  12. import string
  13. typecodes = {
  14.     'Character': 'c',
  15.     'Integer': '1sil',
  16.     'UnsignedInteger': 'bwu',
  17.     'Float': 'fd',
  18.     'Complex': 'FD' }
  19.  
  20. def _get_precisions(typecodes):
  21.     lst = []
  22.     for t in typecodes:
  23.         lst.append((zeros((1,), t).itemsize() * 8, t))
  24.     
  25.     return lst
  26.  
  27.  
  28. def _fill_table(typecodes, table = { }):
  29.     for key, value in typecodes.items():
  30.         table[key] = _get_precisions(value)
  31.     
  32.     return table
  33.  
  34. _code_table = _fill_table(typecodes)
  35.  
  36. class PrecisionError(Exception):
  37.     pass
  38.  
  39.  
  40. def _lookup(table, key, required_bits):
  41.     lst = table[key]
  42.     for bits, typecode in lst:
  43.         if bits >= required_bits:
  44.             return typecode
  45.             continue
  46.     
  47.     raise PrecisionError, key + ' of ' + str(required_bits) + ' bits not available on this system'
  48.  
  49. Character = 'c'
  50.  
  51. try:
  52.     UnsignedInt8 = _lookup(_code_table, 'UnsignedInteger', 8)
  53.     UInt8 = UnsignedInt8
  54. except PrecisionError:
  55.     pass
  56.  
  57.  
  58. try:
  59.     UnsignedInt16 = _lookup(_code_table, 'UnsignedInteger', 16)
  60.     UInt16 = UnsignedInt16
  61. except PrecisionError:
  62.     pass
  63.  
  64.  
  65. try:
  66.     UnsignedInt32 = _lookup(_code_table, 'UnsignedInteger', 32)
  67.     UInt32 = UnsignedInt32
  68. except PrecisionError:
  69.     pass
  70.  
  71.  
  72. try:
  73.     UnsignedInt64 = _lookup(_code_table, 'UnsignedInteger', 64)
  74.     UInt64 = UnsignedInt64
  75. except PrecisionError:
  76.     pass
  77.  
  78.  
  79. try:
  80.     UnsignedInt128 = _lookup(_code_table, 'UnsignedInteger', 128)
  81.     UInt128 = UnsignedInt128
  82. except PrecisionError:
  83.     pass
  84.  
  85. UnsignedInteger = 'u'
  86. UInt = UnsignedInteger
  87.  
  88. try:
  89.     Int0 = _lookup(_code_table, 'Integer', 0)
  90. except PrecisionError:
  91.     pass
  92.  
  93.  
  94. try:
  95.     Int8 = _lookup(_code_table, 'Integer', 8)
  96. except PrecisionError:
  97.     pass
  98.  
  99.  
  100. try:
  101.     Int16 = _lookup(_code_table, 'Integer', 16)
  102. except PrecisionError:
  103.     pass
  104.  
  105.  
  106. try:
  107.     Int32 = _lookup(_code_table, 'Integer', 32)
  108. except PrecisionError:
  109.     pass
  110.  
  111.  
  112. try:
  113.     Int64 = _lookup(_code_table, 'Integer', 64)
  114. except PrecisionError:
  115.     pass
  116.  
  117.  
  118. try:
  119.     Int128 = _lookup(_code_table, 'Integer', 128)
  120. except PrecisionError:
  121.     pass
  122.  
  123. Int = 'l'
  124.  
  125. try:
  126.     Float0 = _lookup(_code_table, 'Float', 0)
  127. except PrecisionError:
  128.     pass
  129.  
  130.  
  131. try:
  132.     Float8 = _lookup(_code_table, 'Float', 8)
  133. except PrecisionError:
  134.     pass
  135.  
  136.  
  137. try:
  138.     Float16 = _lookup(_code_table, 'Float', 16)
  139. except PrecisionError:
  140.     pass
  141.  
  142.  
  143. try:
  144.     Float32 = _lookup(_code_table, 'Float', 32)
  145. except PrecisionError:
  146.     pass
  147.  
  148.  
  149. try:
  150.     Float64 = _lookup(_code_table, 'Float', 64)
  151. except PrecisionError:
  152.     pass
  153.  
  154.  
  155. try:
  156.     Float128 = _lookup(_code_table, 'Float', 128)
  157. except PrecisionError:
  158.     pass
  159.  
  160. Float = 'd'
  161.  
  162. try:
  163.     Complex0 = _lookup(_code_table, 'Complex', 0)
  164. except PrecisionError:
  165.     pass
  166.  
  167.  
  168. try:
  169.     Complex8 = _lookup(_code_table, 'Complex', 16)
  170. except PrecisionError:
  171.     pass
  172.  
  173.  
  174. try:
  175.     Complex16 = _lookup(_code_table, 'Complex', 32)
  176. except PrecisionError:
  177.     pass
  178.  
  179.  
  180. try:
  181.     Complex32 = _lookup(_code_table, 'Complex', 64)
  182. except PrecisionError:
  183.     pass
  184.  
  185.  
  186. try:
  187.     Complex64 = _lookup(_code_table, 'Complex', 128)
  188. except PrecisionError:
  189.     pass
  190.  
  191.  
  192. try:
  193.     Complex128 = _lookup(_code_table, 'Complex', 256)
  194. except PrecisionError:
  195.     pass
  196.  
  197. Complex = 'D'
  198. PyObject = 'O'
  199.